As computerized systems have increased in popularity, so have the needs to distribute files and processing resources of computer systems in networks both large and small. In general, computer systems and related devices communicate information over a network for a variety of reasons, for example, to exchange personal electronic messages, sell merchandise, provide account information, and so forth. One will appreciate, however, that as computer systems and their related applications have become increasingly more sophisticated, the challenges associated with sharing data and resources on a network have also increased.
Some current ways for distributing resources within an organizational network might involve a centralized server (or local device) sharing resources with one or more clients (or remote devices) that typically do not have such resources installed locally. Such systems normally use a dedicated protocol such as Remote Desktop Protocol (“RDP”), Independent Computing Architecture (ICA), and others, to share various applications with a remote client. With such protocols, a client computer system can access a centralized network server, which hosts resources of interest, and interact (e.g., sending mouse and keyboard events, etc.) with those resources just as though those resources were installed locally.
The network server in turn, processes those interactions, creates corresponding rendering information of the data, and sends both the processed data and created rendering information back to the client. The client computer system then receives the data and rendering information, and uses a client-side video driver to render and display the received data locally. Ideally, this interaction between the client computer system and network server occurs seamlessly as though the client computer system had actually processed the data locally with its own installed resources. Unfortunately, such systems can be subject to network throughput constraints, which, if burdened, might result in a “lag” between what the local client computer system views in terms of interaction and processing.
Another type of system that is similar in most respects to the centralized sharing model described above involves a broadcasting (or “sending”) client computer system configured to send window data information to other recipient client computer systems on a network. This feature is also sometimes called “desktop sharing.” In this example, the broadcasting computer (e.g., an “instructor” in a learning environment) and the recipient computer systems (e.g., “students”) connect using a commonly-installed application program that allows for sharing of desktop views and locally installed applications at the instructor computer. Similar to the centralized computing system scenario, the client computer systems might be able to interact with the windows displayed at the instructor computer as though the windows were the student computer's own.
Because bitmaps are expensive in terms of bandwidth consumption when transmitted over a network connection (e.g., the Internet), rather then sending the entire bitmaps most systems nowadays (such as those described above) send graphic primitives and other operations, which tell a sub-routine on the client side what and how to draw something. For example, a client may be told to draw a rectangle along with information about where it should be drawn, what size, color, etc. For instance, a rectangle may be used to draw a button for a user interface, a border around a document, or any other purpose for which a rectangular shape may be useful. Of course, there are many other shapes and operations that can be used as primitives that may be more sophisticated and require more processing that must be done to transfer and perform the operation on the remote client.
Although the above use of primitives have enhanced the seamlessness of networking systems, as applications continue to get more sophisticated graphical interfaces and other displays, the more processing intensive the use of the above primitives becomes. Moreover, the information sent from the local to the remote device for rendering graphics on the display at the client is typically used in an immediate presentation mode where tiled windows results in loss of graphic information. For example, using immediate presentation mode, only the information needed to draw the visible portions of the widows is available. In other words, there is no graphics information retained for portions of windows in the background covered by other windows—i.e., graphics information is only retained for top level window. Accordingly, when a window is moved to the foreground, new information is needed to draw the window. Because of the above noted increase in graphics sophistication, this continual sending of information may overload the system when frequent updates are need—e.g., when windows are shuffled, rotated, and rearranged. This also presents various challenges as it relates to more sophisticated animations.